{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "f543de9b-3858-45dd-bddf-cddddcc60da3",
   "metadata": {},
   "source": [
    "# Part 1: Getting Started with Sionna"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c55670f1-3ee6-481d-9661-d59e61074818",
   "metadata": {},
   "source": [
    "This tutorial will guide you through Sionna, from its basic principles to the implementation of a point-to-point link with a 5G NR compliant code and a 3GPP channel model.\n",
    "You will also learn how to write custom trainable layers by implementing a state of the art neural receiver, and how to train and evaluate end-to-end communication systems.\n",
    "\n",
    "The tutorial is structured in four notebooks:\n",
    "\n",
    "- **Part I: Getting started with Sionna**\n",
    "\n",
    "- Part II: Differentiable Communication Systems\n",
    "\n",
    "- Part III: Advanced Link-level Simulations\n",
    "\n",
    "- Part IV: Toward Learned Receivers\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9b226f39",
   "metadata": {},
   "source": [
    "The [official documentation](https://nvlabs.github.io/sionna) provides key material on how to use Sionna and how its components are implemented."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d7c4211f-beee-4142-9289-c385d0180877",
   "metadata": {},
   "source": [
    "* [Imports & Basics](#Imports-&-Basics)\n",
    "* [A note on random number generation](#A-note-on-random-number-generation)\n",
    "* [Sionna Data-flow and Design Paradigms](#Sionna-Data-flow-and-Design-Paradigms)\n",
    "* [Hello, Sionna!](#Hello,-Sionna!)\n",
    "* [Communication Systems as Models](#Communication-Systems-as-sionna-blocks)\n",
    "* [Forward Error Correction](#Forward-Error-Correction-(FEC))\n",
    "* [Eager vs. Graph Mode](#Eager-vs-Graph-Mode)\n",
    "* [Exercise](#Exercise)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "74a184ac-1f64-407f-9a24-c53d40799be2",
   "metadata": {},
   "source": [
    "## Imports & Basics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "d84bd69e-59f2-4a42-8dd3-730c8c1d821e",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-03-08T13:42:09.956810Z",
     "iopub.status.busy": "2025-03-08T13:42:09.956285Z",
     "iopub.status.idle": "2025-03-08T13:42:12.675257Z",
     "shell.execute_reply": "2025-03-08T13:42:12.674359Z"
    }
   },
   "outputs": [],
   "source": [
    "import os # Configure which GPU \n",
    "if os.getenv(\"CUDA_VISIBLE_DEVICES\") is None:\n",
    "    gpu_num = 0 # Use \"\" to use the CPU\n",
    "    os.environ[\"CUDA_VISIBLE_DEVICES\"] = f\"{gpu_num}\"\n",
    "\n",
    "os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'\n",
    "\n",
    "# Import Sionna\n",
    "try:\n",
    "    import sionna.phy\n",
    "except ImportError as e:\n",
    "    import sys\n",
    "    if 'google.colab' in sys.modules:\n",
    "       # Install Sionna in Google Colab\n",
    "       print(\"Installing Sionna and restarting the runtime. Please run the cell again.\")\n",
    "       os.system(\"pip install sionna\")\n",
    "       os.kill(os.getpid(), 5)\n",
    "    else:\n",
    "       raise e\n",
    "\n",
    "# Configure the notebook to use only a single GPU and allocate only as much memory as needed\n",
    "# For more details, see https://www.tensorflow.org/guide/gpu\n",
    "import tensorflow as tf\n",
    "gpus = tf.config.list_physical_devices('GPU')\n",
    "if gpus:\n",
    "    try:\n",
    "        tf.config.experimental.set_memory_growth(gpus[0], True)\n",
    "    except RuntimeError as e:\n",
    "        print(e)\n",
    "\n",
    "# Avoid warnings from TensorFlow\n",
    "tf.get_logger().setLevel('ERROR')\n",
    "\n",
    "import numpy as np\n",
    "\n",
    "# For plotting\n",
    "%matplotlib inline\n",
    "# also try %matplotlib widget\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# for performance measurements\n",
    "import time"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "42d471a3",
   "metadata": {},
   "source": [
    "We can now access Sionna functions within the `sn` namespace.\n",
    "\n",
    "**Hint**: In Jupyter notebooks, you can run bash commands with `!`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "ec4eb0ab-a34e-45e7-9055-a1555d6f0775",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-03-08T13:42:12.678924Z",
     "iopub.status.busy": "2025-03-08T13:42:12.678478Z",
     "iopub.status.idle": "2025-03-08T13:42:13.386698Z",
     "shell.execute_reply": "2025-03-08T13:42:13.384867Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sat Mar  8 13:42:13 2025       \r\n",
      "+---------------------------------------------------------------------------------------+\r\n",
      "| NVIDIA-SMI 535.183.01             Driver Version: 535.183.01   CUDA Version: 12.2     |\r\n",
      "|-----------------------------------------+----------------------+----------------------+\r\n",
      "| GPU  Name                 Persistence-M | Bus-Id        Disp.A | Volatile Uncorr. ECC |\r\n",
      "| Fan  Temp   Perf          Pwr:Usage/Cap |         Memory-Usage | GPU-Util  Compute M. |\r\n",
      "|                                         |                      |               MIG M. |\r\n",
      "|=========================================+======================+======================|\r\n",
      "|   0  NVIDIA RTX A6000               Off | 00000000:01:00.0 Off |                  Off |\r\n",
      "| 30%   30C    P8              26W / 300W |     70MiB / 49140MiB |      0%      Default |\r\n",
      "|                                         |                      |                  N/A |\r\n",
      "+-----------------------------------------+----------------------+----------------------+\r\n",
      "                                                                                         \r\n",
      "+---------------------------------------------------------------------------------------+\r\n",
      "| Processes:                                                                            |\r\n",
      "|  GPU   GI   CI        PID   Type   Process name                            GPU Memory |\r\n",
      "|        ID   ID                                                             Usage      |\r\n",
      "|=======================================================================================|\r\n",
      "+---------------------------------------------------------------------------------------+\r\n"
     ]
    }
   ],
   "source": [
    "!nvidia-smi"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "865f1607-afc4-4f89-a79f-676c61591bb7",
   "metadata": {},
   "source": [
    "## A note on random number generation\n",
    "When Sionna is loaded, it instantiates random number generators (RNGs) for [Python](https://docs.python.org/3/library/random.html#alternative-generator),\n",
    "[NumPy](https://numpy.org/doc/stable/reference/random/generator.html), and [TensorFlow](https://www.tensorflow.org/api_docs/python/tf/random/Generator). You can optionally set a seed which will make all of your\n",
    "results deterministic, as long as only these RNGs are used. In the cell below,\n",
    "you can see how this seed is set and how the different RNGs can be used."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "953a834a-349d-471b-af47-0e7af410e8c6",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-03-08T13:42:13.392190Z",
     "iopub.status.busy": "2025-03-08T13:42:13.391595Z",
     "iopub.status.idle": "2025-03-08T13:42:13.572638Z",
     "shell.execute_reply": "2025-03-08T13:42:13.571626Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n",
      "5\n",
      "tf.Tensor([2], shape=(1,), dtype=int32)\n"
     ]
    }
   ],
   "source": [
    "sionna.phy.config.seed = 40\n",
    "\n",
    "# Python RNG - use instead of\n",
    "# import random\n",
    "# random.randint(0, 10)\n",
    "print(sionna.phy.config.py_rng.randint(0,10))\n",
    "\n",
    "# NumPy RNG - use instead of\n",
    "# import numpy as np\n",
    "# np.random.randint(0, 10)\n",
    "print(sionna.phy.config.np_rng.integers(0,10))\n",
    "\n",
    "# TensorFlow RNG - use instead of\n",
    "# import tensorflow as tf\n",
    "# tf.random.uniform(shape=[1], minval=0, maxval=10, dtype=tf.int32)\n",
    "print(sionna.phy.config.tf_rng.uniform(shape=[1], minval=0, maxval=10, dtype=tf.int32))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a6294919-0e78-4d6b-835f-55631e6264f6",
   "metadata": {},
   "source": [
    "## Sionna Data-flow and Design Paradigms\n",
    "\n",
    "Sionna inherently parallelizes simulations via *batching*, i.e., each element in the batch dimension is simulated independently.\n",
    "\n",
    "This means the first tensor dimension is always used for *inter-frame* parallelization similar to an outer *for-loop* in Matlab/NumPy simulations, but operations can be operated in parallel.\n",
    "\n",
    "To keep the dataflow efficient, Sionna follows a few simple design principles:\n",
    "\n",
    "* Signal-processing components are implemented as an individual Sionna Blocks..\n",
    "* `tf.float32` is used as preferred datatype and `tf.complex64` for complex-valued datatypes, respectively.  \n",
    "This allows simpler re-use of components (e.g., the same scrambling layer can be used for binary inputs and LLR-values).\n",
    "* `tf.float64`/`tf.complex128` are available when high precision is needed.\n",
    "* Models can be developed in *eager mode* allowing simple (and fast) modification of system parameters.\n",
    "* Number crunching simulations can be executed in the faster *graph mode* or even *XLA* acceleration (experimental) is available for most components.\n",
    "* Whenever possible, components are automatically differentiable via [auto-grad](https://www.tensorflow.org/guide/autodiff) to simplify the deep learning design-flow.\n",
    "* Code is structured into sub-packages for different tasks such as channel coding, mapping,... (see [API documentation](http://nvlabs.github.io/sionna/phy/api/phy.html) for details).\n",
    "\n",
    "These paradigms simplify the re-useability and reliability of our components for a wide range of communications related applications."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fce869c5-5169-4c66-833c-8144414cdda4",
   "metadata": {},
   "source": [
    "## Hello, Sionna!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b52449ca-532c-4c45-8e03-464832717200",
   "metadata": {},
   "source": [
    "Let's start with a very simple simulation: Transmitting QAM symbols over an AWGN channel. We will implement the system shown in the figure below."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "576ea7ca-3dda-4c09-868d-1e2440d35b00",
   "metadata": {},
   "source": [
    "![QAM AWGN]()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "777704cf-0855-4984-86df-b615890811ae",
   "metadata": {},
   "source": [
    "We will use upper case for naming simulation parameters that are used throughout this notebook\n",
    "\n",
    "Every layer needs to be initialized once before it can be used.\n",
    "\n",
    "**Tip**: Use the [API documentation](http://nvlabs.github.io/sionna/phy/api/phy.html) to find an overview of all existing components.\n",
    "You can directly access the signature and the docstring within jupyter via `Shift+TAB`.\n",
    "\n",
    "*Remark*: Most layers are defined to be complex-valued.\n",
    "\n",
    "We first need to create a QAM constellation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "21ccb7b5-b590-4abb-95f7-d939cb283f02",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-03-08T13:42:13.578987Z",
     "iopub.status.busy": "2025-03-08T13:42:13.578760Z",
     "iopub.status.idle": "2025-03-08T13:42:13.837709Z",
     "shell.execute_reply": "2025-03-08T13:42:13.836837Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 700x700 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "NUM_BITS_PER_SYMBOL = 2 # QPSK\n",
    "constellation = sionna.phy.mapping.Constellation(\"qam\", NUM_BITS_PER_SYMBOL)\n",
    "\n",
    "constellation.show();"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6ded88c1-1576-42a5-a180-5bd8da533470",
   "metadata": {
    "tags": []
   },
   "source": [
    "**Task:** Try to change the modulation order, e.g., to 16-QAM."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dcb7b6f1-5dbc-4335-b633-177da8e8a5e3",
   "metadata": {
    "tags": []
   },
   "source": [
    "We then need to setup a mapper to map bits into constellation points. The mapper takes as parameter the constellation.\n",
    "\n",
    "We also need to setup a corresponding demapper to compute log-likelihood ratios (LLRs) from received noisy samples."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "ae9da488-bd0b-40d7-b9fd-31bc6ad7ca3d",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-03-08T13:42:13.841405Z",
     "iopub.status.busy": "2025-03-08T13:42:13.841107Z",
     "iopub.status.idle": "2025-03-08T13:42:13.847154Z",
     "shell.execute_reply": "2025-03-08T13:42:13.846467Z"
    }
   },
   "outputs": [],
   "source": [
    "mapper = sionna.phy.mapping.Mapper(constellation=constellation)\n",
    "\n",
    "# The demapper uses the same constellation object as the mapper\n",
    "demapper = sionna.phy.mapping.Demapper(\"app\", constellation=constellation)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "980fe9ce",
   "metadata": {},
   "source": [
    "**Tip**: You can access the signature+docstring via `?` command and print the complete class definition via `??` operator.\n",
    "\n",
    "Obviously, you can also access the source code via [https://github.com/nvlabs/sionna/](https://github.com/nvlabs/sionna/)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "10f6b1c2",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-03-08T13:42:13.850608Z",
     "iopub.status.busy": "2025-03-08T13:42:13.850275Z",
     "iopub.status.idle": "2025-03-08T13:42:13.909136Z",
     "shell.execute_reply": "2025-03-08T13:42:13.908247Z"
    }
   },
   "outputs": [],
   "source": [
    "# print class definition of the Constellation class\n",
    "sionna.phy.mapping.Mapper??"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "41c23abb-5163-4e08-a2c8-a4b912046b30",
   "metadata": {},
   "source": [
    "As can be seen, the `Mapper` class inherits from `Block`, i.e., implements a *Sionna Block*. These blocks can be connected by simply feeding the output of one block to the next block. This allows to simply build complex systems. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f5d88fc6-f18d-49e7-b66c-98c6361f4a31",
   "metadata": {},
   "source": [
    "Sionna provides as utility a binary source to sample uniform i.i.d. bits."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "8c64222f-1a4b-42da-a37a-3379034de9cd",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-03-08T13:42:13.913088Z",
     "iopub.status.busy": "2025-03-08T13:42:13.912863Z",
     "iopub.status.idle": "2025-03-08T13:42:13.917046Z",
     "shell.execute_reply": "2025-03-08T13:42:13.916303Z"
    }
   },
   "outputs": [],
   "source": [
    "binary_source = sionna.phy.mapping.BinarySource()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8bdaf6cb-5de8-4306-8701-b0e75bbc3fcf",
   "metadata": {},
   "source": [
    "Finally, we need the AWGN channel."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "2665b1a1-945a-4b8c-bc35-49af1b0c26ae",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-03-08T13:42:13.920534Z",
     "iopub.status.busy": "2025-03-08T13:42:13.920257Z",
     "iopub.status.idle": "2025-03-08T13:42:13.924544Z",
     "shell.execute_reply": "2025-03-08T13:42:13.923761Z"
    }
   },
   "outputs": [],
   "source": [
    "awgn_channel = sionna.phy.channel.AWGN()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "261ad816-d4cf-424a-9dff-61444637e4dd",
   "metadata": {},
   "source": [
    "Sionna provides a utility function to compute the noise power spectral density ratio $N_0$ from the energy per bit to noise power spectral density ratio $E_b/N_0$ in dB and a variety of parameters such as the coderate and the nunber of bits per symbol."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "4feb569f-dcc3-465f-94c5-e5d25fad97b2",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-03-08T13:42:13.927144Z",
     "iopub.status.busy": "2025-03-08T13:42:13.926870Z",
     "iopub.status.idle": "2025-03-08T13:42:14.320301Z",
     "shell.execute_reply": "2025-03-08T13:42:14.319251Z"
    }
   },
   "outputs": [],
   "source": [
    "no = sionna.phy.utils.ebnodb2no(ebno_db=10.0,\n",
    "                        num_bits_per_symbol=NUM_BITS_PER_SYMBOL,\n",
    "                        coderate=1.0) # Coderate set to 1 as we do uncoded transmission here"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "efcbe1b0-39d9-4d0f-98bc-84343a46099c",
   "metadata": {},
   "source": [
    "We now have all the components we need to transmit QAM symbols over an AWGN channel.\n",
    "\n",
    "Sionna natively supports multi-dimensional tensors.\n",
    "\n",
    "Most layers operate at the last dimension and can have arbitrary input shapes (preserved at output)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "5747f93e-c89e-41b5-bc77-b6eb13aba4d1",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-03-08T13:42:14.324834Z",
     "iopub.status.busy": "2025-03-08T13:42:14.324617Z",
     "iopub.status.idle": "2025-03-08T13:42:15.413023Z",
     "shell.execute_reply": "2025-03-08T13:42:15.412158Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shape of bits:  (64, 1024)\n",
      "Shape of x:  (64, 512)\n",
      "Shape of y:  (64, 512)\n",
      "Shape of llr:  (64, 1024)\n"
     ]
    }
   ],
   "source": [
    "BATCH_SIZE = 64 # How many examples are processed by Sionna in parallel\n",
    "\n",
    "bits = binary_source([BATCH_SIZE,\n",
    "                      1024]) # Blocklength\n",
    "print(\"Shape of bits: \", bits.shape)\n",
    "\n",
    "x = mapper(bits)\n",
    "print(\"Shape of x: \", x.shape)\n",
    "\n",
    "y = awgn_channel(x, no)\n",
    "print(\"Shape of y: \", y.shape)\n",
    "\n",
    "llr = demapper(y, no)\n",
    "print(\"Shape of llr: \", llr.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aca7a98b",
   "metadata": {},
   "source": [
    "In *Eager* mode, we can directly access the values of each tensor. This simplifies debugging."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "abffb7f3",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-03-08T13:42:15.417066Z",
     "iopub.status.busy": "2025-03-08T13:42:15.416837Z",
     "iopub.status.idle": "2025-03-08T13:42:15.426932Z",
     "shell.execute_reply": "2025-03-08T13:42:15.426156Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "First 8 transmitted bits: [1. 0. 0. 0. 0. 1. 0. 0.]\n",
      "First 4 transmitted symbols: [-0.71+0.71j  0.71+0.71j  0.71-0.71j  0.71+0.71j]\n",
      "First 4 received symbols: [-0.89+0.69j  0.79+0.66j  0.98-0.68j  0.73+0.71j]\n",
      "First 8 demapped llrs: [ 50.15 -39.18 -44.58 -37.22 -55.23  38.73 -41.16 -39.93]\n"
     ]
    }
   ],
   "source": [
    "num_samples = 8 # how many samples shall be printed\n",
    "num_symbols = int(num_samples/NUM_BITS_PER_SYMBOL)\n",
    "\n",
    "print(f\"First {num_samples} transmitted bits: {bits[0,:num_samples]}\")\n",
    "print(f\"First {num_symbols} transmitted symbols: {np.round(x[0,:num_symbols], 2)}\")\n",
    "print(f\"First {num_symbols} received symbols: {np.round(y[0,:num_symbols], 2)}\")\n",
    "print(f\"First {num_samples} demapped llrs: {np.round(llr[0,:num_samples], 2)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1d92339a-44ae-45d9-a59c-bde99e3bd656",
   "metadata": {},
   "source": [
    "Let's visualize the received noisy samples."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "682509f0-e734-4aec-bc05-773bd576de16",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-03-08T13:42:15.429449Z",
     "iopub.status.busy": "2025-03-08T13:42:15.429217Z",
     "iopub.status.idle": "2025-03-08T13:42:15.759786Z",
     "shell.execute_reply": "2025-03-08T13:42:15.759107Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x800 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(8,8))\n",
    "plt.axes().set_aspect(1)\n",
    "plt.grid(True)\n",
    "plt.title('Channel output')\n",
    "plt.xlabel('Real Part')\n",
    "plt.ylabel('Imaginary Part')\n",
    "plt.scatter(tf.math.real(y), tf.math.imag(y))\n",
    "plt.tight_layout()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d415e3e0-65ee-488f-a29b-5909dce48ede",
   "metadata": {},
   "source": [
    "**Task:** One can play with the SNR to visualize the impact on the received samples.\n",
    "\n",
    "**Advanced Task:** Compare the LLR distribution for \"app\" demapping with \"maxlog\" demapping.\n",
    "The [Bit-Interleaved Coded Modulation](https://nvlabs.github.io/sionna/phy/tutorials/Bit_Interleaved_Coded_Modulation.html) example notebook can be helpful for this task.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dfab1249-a6c1-430a-a204-a9c631a82700",
   "metadata": {},
   "source": [
    "## Communication Systems as Sionna Blocks"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bfc184ba-c090-4443-9cd6-c217b3f64052",
   "metadata": {},
   "source": [
    "It is typically more convenient to wrap a Sionna-based communication system into a Sionna Block acting as end-to-end model.\n",
    "\n",
    "These models can be simply built by stacking different Sionna components (i.e., Sionna Blocks).\n",
    "\n",
    "The following cell implements the previous system as a end-to-end model.\n",
    "\n",
    "The key functions that need to be defined are `__init__()`, which instantiates the required components, and `__call()__`, which performs forward pass through the end-to-end system."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "ee71bdbf-14c7-464f-b90d-450cb7b070b7",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-03-08T13:42:15.765043Z",
     "iopub.status.busy": "2025-03-08T13:42:15.764811Z",
     "iopub.status.idle": "2025-03-08T13:42:15.771347Z",
     "shell.execute_reply": "2025-03-08T13:42:15.770730Z"
    }
   },
   "outputs": [],
   "source": [
    "class UncodedSystemAWGN(sionna.phy.Block):\n",
    "    def __init__(self, num_bits_per_symbol, block_length):\n",
    "        \"\"\"\n",
    "        A Sionna Block for uncoded transmission over the AWGN channel\n",
    "\n",
    "        Parameters\n",
    "        ----------\n",
    "        num_bits_per_symbol: int\n",
    "            The number of bits per constellation symbol, e.g., 4 for QAM16.\n",
    "\n",
    "        block_length: int\n",
    "            The number of bits per transmitted message block (will be the codeword length later).\n",
    "\n",
    "        Input\n",
    "        -----\n",
    "        batch_size: int\n",
    "            The batch_size of the Monte-Carlo simulation.\n",
    "\n",
    "        ebno_db: float\n",
    "            The `Eb/No` value (=rate-adjusted SNR) in dB.\n",
    "\n",
    "        Output\n",
    "        ------\n",
    "        (bits, llr):\n",
    "            Tuple:\n",
    "\n",
    "        bits: tf.float32\n",
    "            A tensor of shape `[batch_size, block_length] of 0s and 1s\n",
    "            containing the transmitted information bits.\n",
    "\n",
    "        llr: tf.float32\n",
    "            A tensor of shape `[batch_size, block_length] containing the\n",
    "            received log-likelihood-ratio (LLR) values.\n",
    "        \"\"\"\n",
    "\n",
    "        super().__init__() # Must call the block initializer\n",
    "\n",
    "        self.num_bits_per_symbol = num_bits_per_symbol\n",
    "        self.block_length = block_length\n",
    "        self.constellation = sionna.phy.mapping.Constellation(\"qam\", self.num_bits_per_symbol)\n",
    "        self.mapper = sionna.phy.mapping.Mapper(constellation=self.constellation)\n",
    "        self.demapper = sionna.phy.mapping.Demapper(\"app\", constellation=self.constellation)\n",
    "        self.binary_source = sionna.phy.mapping.BinarySource()\n",
    "        self.awgn_channel = sionna.phy.channel.AWGN()\n",
    "\n",
    "    # @tf.function # Enable graph execution to speed things up\n",
    "    def call(self, batch_size, ebno_db):\n",
    "\n",
    "        # no channel coding used; we set coderate=1.0\n",
    "        no = sionna.phy.utils.ebnodb2no(ebno_db,\n",
    "                                num_bits_per_symbol=self.num_bits_per_symbol,\n",
    "                                coderate=1.0)\n",
    "\n",
    "        bits = self.binary_source([batch_size, self.block_length]) # Blocklength set to 1024 bits\n",
    "        x = self.mapper(bits)\n",
    "        y = self.awgn_channel(x, no)\n",
    "        llr = self.demapper(y,no)\n",
    "        return bits, llr"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c2397775-1a9d-467c-8048-0949a25bda02",
   "metadata": {},
   "source": [
    "We need first to instantiate the model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "3212d737-3ae0-4158-983b-6d0667cc1dd8",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-03-08T13:42:15.774071Z",
     "iopub.status.busy": "2025-03-08T13:42:15.773823Z",
     "iopub.status.idle": "2025-03-08T13:42:15.779861Z",
     "shell.execute_reply": "2025-03-08T13:42:15.779180Z"
    }
   },
   "outputs": [],
   "source": [
    "model_uncoded_awgn = UncodedSystemAWGN(num_bits_per_symbol=NUM_BITS_PER_SYMBOL, block_length=1024)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5e449509-4ba0-4e14-8a6a-91e55a7efec4",
   "metadata": {},
   "source": [
    "Sionna provides a utility to easily compute and plot the bit error rate (BER)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "34534be8-947d-4d29-8e58-1c7d0dce96c9",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-03-08T13:42:15.782830Z",
     "iopub.status.busy": "2025-03-08T13:42:15.782564Z",
     "iopub.status.idle": "2025-03-08T13:42:17.983251Z",
     "shell.execute_reply": "2025-03-08T13:42:17.982592Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "EbNo [dB] |        BER |       BLER |  bit errors |    num bits | block errors |  num blocks | runtime [s] |    status\n",
      "---------------------------------------------------------------------------------------------------------------------------------------\n",
      "     -3.0 | 1.5806e-01 | 1.0000e+00 |      323698 |     2048000 |         2000 |        2000 |         0.1 |reached target block errors\n",
      "   -2.579 | 1.4673e-01 | 1.0000e+00 |      300503 |     2048000 |         2000 |        2000 |         0.0 |reached target block errors\n",
      "   -2.158 | 1.3499e-01 | 1.0000e+00 |      276463 |     2048000 |         2000 |        2000 |         0.0 |reached target block errors\n",
      "   -1.737 | 1.2345e-01 | 1.0000e+00 |      252831 |     2048000 |         2000 |        2000 |         0.0 |reached target block errors\n",
      "   -1.316 | 1.1180e-01 | 1.0000e+00 |      228960 |     2048000 |         2000 |        2000 |         0.0 |reached target block errors\n",
      "   -0.895 | 1.0129e-01 | 1.0000e+00 |      207442 |     2048000 |         2000 |        2000 |         0.0 |reached target block errors\n",
      "   -0.474 | 9.0589e-02 | 1.0000e+00 |      185527 |     2048000 |         2000 |        2000 |         0.0 |reached target block errors\n",
      "   -0.053 | 7.9652e-02 | 1.0000e+00 |      163127 |     2048000 |         2000 |        2000 |         0.0 |reached target block errors\n",
      "    0.368 | 6.9911e-02 | 1.0000e+00 |      143178 |     2048000 |         2000 |        2000 |         0.0 |reached target block errors\n",
      "    0.789 | 6.0820e-02 | 1.0000e+00 |      124560 |     2048000 |         2000 |        2000 |         0.0 |reached target block errors\n",
      "    1.211 | 5.2066e-02 | 1.0000e+00 |      106631 |     2048000 |         2000 |        2000 |         0.0 |reached target block errors\n",
      "    1.632 | 4.4058e-02 | 1.0000e+00 |       90230 |     2048000 |         2000 |        2000 |         0.0 |reached target block errors\n",
      "    2.053 | 3.6521e-02 | 1.0000e+00 |       74795 |     2048000 |         2000 |        2000 |         0.0 |reached target block errors\n",
      "    2.474 | 2.9968e-02 | 1.0000e+00 |       61374 |     2048000 |         2000 |        2000 |         0.0 |reached target block errors\n",
      "    2.895 | 2.4220e-02 | 1.0000e+00 |       49602 |     2048000 |         2000 |        2000 |         0.0 |reached target block errors\n",
      "    3.316 | 1.8940e-02 | 1.0000e+00 |       38790 |     2048000 |         2000 |        2000 |         0.0 |reached target block errors\n",
      "    3.737 | 1.4792e-02 | 1.0000e+00 |       30294 |     2048000 |         2000 |        2000 |         0.0 |reached target block errors\n",
      "    4.158 | 1.1268e-02 | 9.9950e-01 |       23077 |     2048000 |         1999 |        2000 |         0.0 |reached target block errors\n",
      "    4.579 | 8.3135e-03 | 9.9950e-01 |       17026 |     2048000 |         1999 |        2000 |         0.0 |reached target block errors\n",
      "      5.0 | 5.9688e-03 | 9.9600e-01 |       12224 |     2048000 |         1992 |        2000 |         0.0 |reached target block errors\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1600x1000 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "EBN0_DB_MIN = -3.0 # Minimum value of Eb/N0 [dB] for simulations\n",
    "EBN0_DB_MAX = 5.0 # Maximum value of Eb/N0 [dB] for simulations\n",
    "BATCH_SIZE = 2000 # How many examples are processed by Sionna in parallel\n",
    "\n",
    "ber_plots = sionna.phy.utils.PlotBER(\"AWGN\")\n",
    "ber_plots.simulate(model_uncoded_awgn,\n",
    "                  ebno_dbs=np.linspace(EBN0_DB_MIN, EBN0_DB_MAX, 20),\n",
    "                  batch_size=BATCH_SIZE,\n",
    "                  num_target_block_errors=100, # simulate until 100 block errors occured\n",
    "                  legend=\"Uncoded\",\n",
    "                  soft_estimates=True,\n",
    "                  max_mc_iter=100, # run 100 Monte-Carlo simulations (each with batch_size samples)\n",
    "                  show_fig=True);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "70e75524",
   "metadata": {},
   "source": [
    "The `sionna.phy.utils.PlotBER` object stores the results and allows to add additional simulations to the previous curves.\n",
    "\n",
    "*Remark*: In Sionna, a block error is defined to happen if for two tensors at least one position in the last dimension differs (i.e., at least one bit wrongly received per codeword).\n",
    "The bit error rate the total number of erroneous positions divided by the total number of transmitted bits."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b7c8f75c-65c8-4440-a8bd-fca7e3d8f35f",
   "metadata": {},
   "source": [
    "## Forward Error Correction (FEC)\n",
    "\n",
    "We now add channel coding to our transceiver to make it more robust against transmission errors. For this, we will use [5G compliant low-density parity-check (LDPC) codes and Polar codes](https://portal.3gpp.org/desktopmodules/Specifications/SpecificationDetails.aspx?specificationId=3214).\n",
    "You can find more detailed information in the notebooks [Bit-Interleaved Coded Modulation (BICM)](https://nvlabs.github.io/sionna/phy/tutorials/Bit_Interleaved_Coded_Modulation.html) and [5G Channel Coding and Rate-Matching: Polar vs. LDPC Codes](https://nvlabs.github.io/sionna/phy/tutorials/5G_Channel_Coding_Polar_vs_LDPC_Codes.html)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "b6800065",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-03-08T13:42:17.986278Z",
     "iopub.status.busy": "2025-03-08T13:42:17.985961Z",
     "iopub.status.idle": "2025-03-08T13:42:18.027437Z",
     "shell.execute_reply": "2025-03-08T13:42:18.026806Z"
    }
   },
   "outputs": [],
   "source": [
    "k = 12\n",
    "n = 20\n",
    "\n",
    "encoder = sionna.phy.fec.ldpc.LDPC5GEncoder(k, n)\n",
    "decoder = sionna.phy.fec.ldpc.LDPC5GDecoder(encoder, hard_out=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "39673cbe",
   "metadata": {},
   "source": [
    "Let us encode some random input bits."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "6e940732",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-03-08T13:42:18.030904Z",
     "iopub.status.busy": "2025-03-08T13:42:18.030593Z",
     "iopub.status.idle": "2025-03-08T13:42:18.656270Z",
     "shell.execute_reply": "2025-03-08T13:42:18.655654Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Input bits are: \n",
      " [[0. 0. 0. 0. 1. 0. 0. 1. 1. 1. 1. 1.]]\n",
      "Encoded bits are: \n",
      " [[1. 0. 0. 1. 1. 1. 1. 1. 0. 1. 1. 0. 1. 1. 1. 1. 0. 1. 1. 0.]]\n"
     ]
    }
   ],
   "source": [
    "BATCH_SIZE = 1 # one codeword in parallel\n",
    "u = binary_source([BATCH_SIZE, k])\n",
    "print(\"Input bits are: \\n\", u.numpy())\n",
    "\n",
    "c = encoder(u)\n",
    "print(\"Encoded bits are: \\n\", c.numpy())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "99a5303a",
   "metadata": {},
   "source": [
    "One of the fundamental paradigms of Sionna is batch-processing.\n",
    "Thus, the example above could be executed for arbitrary batch-sizes to simulate `batch_size` codewords in parallel.\n",
    "\n",
    "However, Sionna can do more - it supports *N*-dimensional input tensors and, thereby, allows the processing of multiple samples of multiple users and several antennas in a single command line.\n",
    "Let's say we want to encode `batch_size` codewords of length `n` for each of the `num_users` connected to each of the `num_basestations`. \n",
    "This means in total we transmit `batch_size` * `n` * `num_users` * `num_basestations` bits."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e89a7fc4",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-03-08T13:42:18.660325Z",
     "iopub.status.busy": "2025-03-08T13:42:18.659998Z",
     "iopub.status.idle": "2025-03-08T13:42:18.714184Z",
     "shell.execute_reply": "2025-03-08T13:42:18.713567Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shape of u:  (10, 4, 5, 500)\n",
      "Shape of c:  (10, 4, 5, 1000)\n",
      "Total number of processed bits:  200000\n"
     ]
    }
   ],
   "source": [
    "BATCH_SIZE = 10 # samples per scenario\n",
    "num_basestations = 4\n",
    "num_users = 5 # users per basestation\n",
    "n = 1000 # codeword length per transmitted codeword\n",
    "coderate = 0.5 # coderate\n",
    "\n",
    "k = int(coderate * n) # number of info bits per codeword\n",
    "\n",
    "# instantiate a new encoder for codewords of length n\n",
    "encoder = sionna.phy.fec.ldpc.LDPC5GEncoder(k, n)\n",
    "\n",
    "# the decoder must be linked to the encoder (to know the exact code parameters used for encoding)\n",
    "decoder = sionna.phy.fec.ldpc.LDPC5GDecoder(encoder,\n",
    "                                    hard_out=True, # binary output or provide soft-estimates\n",
    "                                    return_infobits=True, # or also return (decoded) parity bits\n",
    "                                    num_iter=20, # number of decoding iterations\n",
    "                                    cn_update=\"boxplus-phi\") # also try \"minsum\" decoding\n",
    "\n",
    "# draw random bits to encode\n",
    "u = binary_source([BATCH_SIZE, num_basestations, num_users, k])\n",
    "print(\"Shape of u: \", u.shape)\n",
    "\n",
    "# We can immediately encode u for all users, basetation and samples\n",
    "# This all happens with a single line of code\n",
    "c = encoder(u)\n",
    "print(\"Shape of c: \", c.shape)\n",
    "\n",
    "print(\"Total number of processed bits: \", np.prod(c.shape))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2f19f80a",
   "metadata": {},
   "source": [
    "This works for arbitrary dimensions and allows a simple extension of the designed system to multi-user or multi-antenna scenarios.\n",
    "\n",
    "Let us now replace the LDPC code by a Polar code. The API remains similar."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "b05b3fd2",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-03-08T13:42:18.717905Z",
     "iopub.status.busy": "2025-03-08T13:42:18.717596Z",
     "iopub.status.idle": "2025-03-08T13:42:18.726892Z",
     "shell.execute_reply": "2025-03-08T13:42:18.726053Z"
    }
   },
   "outputs": [],
   "source": [
    "k = 64\n",
    "n = 128\n",
    "\n",
    "encoder = sionna.phy.fec.polar.Polar5GEncoder(k, n)\n",
    "decoder = sionna.phy.fec.polar.Polar5GDecoder(encoder,\n",
    "                                      dec_type=\"SCL\") # you can also use \"SCL\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8f00d4b2",
   "metadata": {},
   "source": [
    "*Advanced Remark:* The 5G Polar encoder/decoder class directly applies rate-matching and the additional CRC concatenation. \n",
    "This is all done internally and transparent to the user.\n",
    "\n",
    "In case you want to access low-level features of the Polar codes, please use `sionna.fec.polar.PolarEncoder` and the desired decoder (`sionna.fec.polar.PolarSCDecoder`, `sionna.fec.polar.PolarSCLDecoder` or `sionna.fec.polar.PolarBPDecoder`).\n",
    "\n",
    "Further details can be found in the tutorial notebook on [5G Channel Coding and Rate-Matching: Polar vs. LDPC Codes](https://nvlabs.github.io/sionna/phy/tutorials/5G_Channel_Coding_Polar_vs_LDPC_Codes.html).\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "708efce7-2145-4637-981a-5a38a315a9b6",
   "metadata": {},
   "source": [
    "![QAM FEC AWGN]()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "39b597a6-8eef-4ba5-91e7-f030c5fedae4",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-03-08T13:42:18.729858Z",
     "iopub.status.busy": "2025-03-08T13:42:18.729538Z",
     "iopub.status.idle": "2025-03-08T13:42:18.736267Z",
     "shell.execute_reply": "2025-03-08T13:42:18.735655Z"
    }
   },
   "outputs": [],
   "source": [
    "class CodedSystemAWGN(sionna.phy.Block):\n",
    "    def __init__(self, num_bits_per_symbol, n, coderate):\n",
    "        super().__init__() # Must call the Sionna block initializer\n",
    "\n",
    "        self.num_bits_per_symbol = num_bits_per_symbol\n",
    "        self.n = n\n",
    "        self.k = int(n*coderate)\n",
    "        self.coderate = coderate\n",
    "        self.constellation = sionna.phy.mapping.Constellation(\"qam\", self.num_bits_per_symbol)\n",
    "\n",
    "        self.mapper = sionna.phy.mapping.Mapper(constellation=self.constellation)\n",
    "        self.demapper = sionna.phy.mapping.Demapper(\"app\", constellation=self.constellation)\n",
    "\n",
    "        self.binary_source = sionna.phy.mapping.BinarySource()\n",
    "        self.awgn_channel = sionna.phy.channel.AWGN()\n",
    "\n",
    "        self.encoder = sionna.phy.fec.ldpc.LDPC5GEncoder(self.k, self.n)\n",
    "        self.decoder = sionna.phy.fec.ldpc.LDPC5GDecoder(self.encoder, hard_out=True)\n",
    "\n",
    "    #@tf.function # activate graph execution to speed things up\n",
    "    def call(self, batch_size, ebno_db):\n",
    "        no = sionna.phy.utils.ebnodb2no(ebno_db, num_bits_per_symbol=self.num_bits_per_symbol, coderate=self.coderate)\n",
    "\n",
    "        bits = self.binary_source([batch_size, self.k])\n",
    "        codewords = self.encoder(bits)\n",
    "        x = self.mapper(codewords)\n",
    "        y = self.awgn_channel(x, no)\n",
    "        llr = self.demapper(y,no)\n",
    "        bits_hat = self.decoder(llr)\n",
    "        return bits, bits_hat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "056e25da-3d0a-416d-ac6c-98b15bc042e7",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-03-08T13:42:18.738974Z",
     "iopub.status.busy": "2025-03-08T13:42:18.738658Z",
     "iopub.status.idle": "2025-03-08T13:42:43.810071Z",
     "shell.execute_reply": "2025-03-08T13:42:43.809426Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "EbNo [dB] |        BER |       BLER |  bit errors |    num bits | block errors |  num blocks | runtime [s] |    status\n",
      "---------------------------------------------------------------------------------------------------------------------------------------\n",
      "     -3.0 | 2.7968e-01 | 1.0000e+00 |      572778 |     2048000 |         2000 |        2000 |         2.1 |reached target block errors\n",
      "   -2.429 | 2.6357e-01 | 1.0000e+00 |      539791 |     2048000 |         2000 |        2000 |         0.6 |reached target block errors\n",
      "   -1.857 | 2.4671e-01 | 1.0000e+00 |      505261 |     2048000 |         2000 |        2000 |         0.6 |reached target block errors\n",
      "   -1.286 | 2.2724e-01 | 1.0000e+00 |      465395 |     2048000 |         2000 |        2000 |         0.6 |reached target block errors\n",
      "   -0.714 | 2.0353e-01 | 1.0000e+00 |      416826 |     2048000 |         2000 |        2000 |         0.6 |reached target block errors\n",
      "   -0.143 | 1.7185e-01 | 1.0000e+00 |      351951 |     2048000 |         2000 |        2000 |         0.6 |reached target block errors\n",
      "    0.429 | 1.1305e-01 | 9.9200e-01 |      231528 |     2048000 |         1984 |        2000 |         0.6 |reached target block errors\n",
      "      1.0 | 1.9613e-02 | 4.6450e-01 |       40168 |     2048000 |          929 |        2000 |         0.6 |reached target block errors\n",
      "    1.571 | 2.4287e-04 | 1.3533e-02 |        7461 |    30720000 |          406 |       30000 |         9.0 |reached max iterations\n",
      "    2.143 | 0.0000e+00 | 0.0000e+00 |           0 |    30720000 |            0 |       30000 |         9.2 |reached max iterations\n",
      "\n",
      "Simulation stopped as no error occurred @ EbNo = 2.1 dB.\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1600x1000 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "CODERATE = 0.5\n",
    "BATCH_SIZE = 2000\n",
    "\n",
    "model_coded_awgn = CodedSystemAWGN(num_bits_per_symbol=NUM_BITS_PER_SYMBOL,\n",
    "                                   n=2048,\n",
    "                                   coderate=CODERATE)\n",
    "ber_plots.simulate(model_coded_awgn,\n",
    "                   ebno_dbs=np.linspace(EBN0_DB_MIN, EBN0_DB_MAX, 15),\n",
    "                   batch_size=BATCH_SIZE,\n",
    "                   num_target_block_errors=500,\n",
    "                   legend=\"Coded\",\n",
    "                   soft_estimates=False,\n",
    "                   max_mc_iter=15,\n",
    "                   show_fig=True,\n",
    "                   forward_keyboard_interrupt=False);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "df537cad",
   "metadata": {},
   "source": [
    "As can be seen, the `BerPlot` class uses multiple stopping conditions and stops the simulation after no error occured at a specifc SNR point."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7e7902e8",
   "metadata": {},
   "source": [
    "**Task**: Replace the coding scheme by a Polar encoder/decoder or a convolutional code with Viterbi decoding."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c02ebb11",
   "metadata": {},
   "source": [
    "## Eager vs Graph Mode\n",
    "\n",
    "So far, we have executed the example in *eager* mode. \n",
    "This allows to run TensorFlow ops as if it was written NumPy and simplifies development and debugging.\n",
    "\n",
    "However, to unleash Sionna's full performance, we need to activate *graph* mode which can be enabled with the function decorator *@tf.function()*.\n",
    "\n",
    "We refer to [TensorFlow Functions](https://www.tensorflow.org/guide/function) for further details.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "b3bc7a86",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-03-08T13:42:43.814838Z",
     "iopub.status.busy": "2025-03-08T13:42:43.814536Z",
     "iopub.status.idle": "2025-03-08T13:42:43.818655Z",
     "shell.execute_reply": "2025-03-08T13:42:43.817957Z"
    }
   },
   "outputs": [],
   "source": [
    "@tf.function() # enables graph-mode of the following function\n",
    "def run_graph(batch_size, ebno_db):\n",
    "    # all code inside this function will be executed in graph mode, also calls of other functions\n",
    "    print(f\"Tracing run_graph for values batch_size={batch_size} and ebno_db={ebno_db}.\") # print whenever this function is traced\n",
    "    return model_coded_awgn(batch_size, ebno_db)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "64a7c186",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-03-08T13:42:43.822463Z",
     "iopub.status.busy": "2025-03-08T13:42:43.822107Z",
     "iopub.status.idle": "2025-03-08T13:42:46.108997Z",
     "shell.execute_reply": "2025-03-08T13:42:46.108307Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tracing run_graph for values batch_size=10 and ebno_db=1.5.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(<tf.Tensor: shape=(10, 1024), dtype=float32, numpy=\n",
       " array([[0., 0., 0., ..., 1., 0., 1.],\n",
       "        [0., 1., 1., ..., 0., 0., 0.],\n",
       "        [1., 1., 0., ..., 0., 0., 1.],\n",
       "        ...,\n",
       "        [0., 1., 0., ..., 1., 1., 1.],\n",
       "        [1., 1., 1., ..., 0., 0., 0.],\n",
       "        [0., 0., 0., ..., 1., 1., 0.]], dtype=float32)>,\n",
       " <tf.Tensor: shape=(10, 1024), dtype=float32, numpy=\n",
       " array([[0., 0., 0., ..., 1., 0., 1.],\n",
       "        [0., 1., 1., ..., 0., 0., 0.],\n",
       "        [1., 1., 0., ..., 0., 0., 1.],\n",
       "        ...,\n",
       "        [0., 1., 0., ..., 1., 1., 1.],\n",
       "        [1., 1., 1., ..., 0., 0., 0.],\n",
       "        [0., 0., 0., ..., 1., 1., 0.]], dtype=float32)>)"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "batch_size = 10 # try also different batch sizes\n",
    "ebno_db = 1.5\n",
    "\n",
    "# run twice - how does the output change?\n",
    "run_graph(batch_size, ebno_db)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e76ffd1d",
   "metadata": {},
   "source": [
    "In graph mode, Python code (i.e., *non-TensorFlow code*) is only executed whenever the function is *traced*.\n",
    "This happens whenever the input signature changes.\n",
    "\n",
    "As can be seen above, the print statement was executed, i.e., the graph was traced again.\n",
    "\n",
    "To avoid this re-tracing for different inputs, we now input tensors.\n",
    "You can see that the function is now traced once for input tensors of same dtype.\n",
    "\n",
    "See [TensorFlow Rules of Tracing](https://www.tensorflow.org/guide/function#rules_of_tracing) for details.\n",
    "\n",
    "**Task:** change the code above such that tensors are used as input and execute the code with different input values. Understand when re-tracing happens.\n",
    "\n",
    "*Remark*: if the input to a function is a tensor its signature must change and not *just* its value. For example the input could have a different size or datatype.\n",
    "For efficient code execution, we usually want to avoid re-tracing of the code if not required."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "b5f3704f",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-03-08T13:42:46.112627Z",
     "iopub.status.busy": "2025-03-08T13:42:46.112255Z",
     "iopub.status.idle": "2025-03-08T13:42:46.118213Z",
     "shell.execute_reply": "2025-03-08T13:42:46.117348Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Input Parameters:\n",
      "  batch_size (POSITIONAL_OR_KEYWORD): Literal[10]\n",
      "  ebno_db (POSITIONAL_OR_KEYWORD): Literal[1.5]\n",
      "Output Type:\n",
      "  Tuple[TensorSpec(shape=(10, 1024), dtype=tf.float32, name=None), TensorSpec(shape=(10, 1024), dtype=tf.float32, name=None)]\n",
      "Captures:\n",
      "  140547178192512: TensorSpec(shape=(), dtype=tf.resource, name=None)\n",
      "  140547179593424: TensorSpec(shape=(416, 8), dtype=tf.int32, name=None)\n",
      "  140547339563632: TensorSpec(shape=(416, 6), dtype=tf.int32, name=None)\n",
      "  140547339565744: TensorSpec(shape=(3952, 4), dtype=tf.int32, name=None)\n",
      "  140547339566800: TensorSpec(shape=(3952, 2), dtype=tf.int32, name=None)\n",
      "  140547341697616: TensorSpec(shape=(2,), dtype=tf.int32, name=None)\n",
      "  140547339564160: TensorSpec(shape=(4,), dtype=tf.complex64, name=None)\n",
      "  140547339558176: TensorSpec(shape=(), dtype=tf.float32, name=None)\n",
      "  140547339562752: TensorSpec(shape=(2, 2), dtype=tf.int32, name=None)\n",
      "  140547339559760: TensorSpec(shape=(2, 2), dtype=tf.int32, name=None)\n",
      "  140547339561520: TensorSpec(shape=(), dtype=tf.float32, name=None)\n",
      "  140547339559936: TensorSpec(shape=(), dtype=tf.int32, name=None)\n",
      "  140547339566448: TensorSpec(shape=(7928,), dtype=tf.int64, name=None)\n",
      "  140547339565040: TensorSpec(shape=(1233,), dtype=tf.int32, name=None)\n",
      "  140547339563280: TensorSpec(shape=(7928,), dtype=tf.int32, name=None)\n",
      "  140547339559584: TensorSpec(shape=(7928,), dtype=tf.int64, name=None)\n",
      "  140547337715952: TensorSpec(shape=(2273,), dtype=tf.int32, name=None)\n",
      "  140547339560640: TensorSpec(shape=(7928,), dtype=tf.int32, name=None)\n"
     ]
    }
   ],
   "source": [
    "# You can print the cached signatures with\n",
    "print(run_graph.pretty_printed_concrete_signatures())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b3664c47",
   "metadata": {},
   "source": [
    "We now compare the throughput of the different modes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "d3f22327",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-03-08T13:42:46.121537Z",
     "iopub.status.busy": "2025-03-08T13:42:46.121189Z",
     "iopub.status.idle": "2025-03-08T13:42:50.053697Z",
     "shell.execute_reply": "2025-03-08T13:42:50.052242Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Throughput in Eager mode: 3.408 Mbit/s\n",
      "Tracing run_graph for values batch_size=Tensor(\"batch_size:0\", shape=(), dtype=int32) and ebno_db=Tensor(\"ebno_db:0\", shape=(), dtype=float32).\n",
      "Throughput in graph mode: 10.995 Mbit/s\n"
     ]
    }
   ],
   "source": [
    "repetitions = 4 # average over multiple runs\n",
    "batch_size = BATCH_SIZE # try also different batch sizes\n",
    "ebno_db = 1.5\n",
    "\n",
    "# --- eager mode ---\n",
    "t_start = time.perf_counter()\n",
    "for _ in range(repetitions):\n",
    "    bits, bits_hat = model_coded_awgn(tf.constant(batch_size, tf.int32),\n",
    "                                tf.constant(ebno_db, tf. float32))\n",
    "t_stop = time.perf_counter()\n",
    "# throughput in bit/s\n",
    "throughput_eager = np.size(bits.numpy())*repetitions / (t_stop - t_start) / 1e6\n",
    "\n",
    "print(f\"Throughput in Eager mode: {throughput_eager :.3f} Mbit/s\")\n",
    "# --- graph mode ---\n",
    "# run once to trace graph (ignored for throughput)\n",
    "run_graph(tf.constant(batch_size, tf.int32),\n",
    "          tf.constant(ebno_db, tf. float32))\n",
    "\n",
    "t_start = time.perf_counter()\n",
    "for _ in range(repetitions):\n",
    "    bits, bits_hat = run_graph(tf.constant(batch_size, tf.int32),\n",
    "                                tf.constant(ebno_db, tf. float32))\n",
    "t_stop = time.perf_counter()\n",
    "# throughput in bit/s\n",
    "throughput_graph = np.size(bits.numpy())*repetitions / (t_stop - t_start) / 1e6\n",
    "\n",
    "print(f\"Throughput in graph mode: {throughput_graph :.3f} Mbit/s\")\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "749d2355",
   "metadata": {},
   "source": [
    "Let's run the same simulation as above in graph mode."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "1de9bbf6",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-03-08T13:42:50.058394Z",
     "iopub.status.busy": "2025-03-08T13:42:50.057986Z",
     "iopub.status.idle": "2025-03-08T13:43:34.978472Z",
     "shell.execute_reply": "2025-03-08T13:43:34.977191Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "EbNo [dB] |        BER |       BLER |  bit errors |    num bits | block errors |  num blocks | runtime [s] |    status\n",
      "---------------------------------------------------------------------------------------------------------------------------------------\n",
      "     -3.0 | 2.7972e-01 | 1.0000e+00 |      572859 |     2048000 |         2000 |        2000 |         0.2 |reached target block errors\n",
      "   -2.273 | 2.5935e-01 | 1.0000e+00 |      531157 |     2048000 |         2000 |        2000 |         0.2 |reached target block errors\n",
      "   -1.545 | 2.3590e-01 | 1.0000e+00 |      483122 |     2048000 |         2000 |        2000 |         0.2 |reached target block errors\n",
      "   -0.818 | 2.0800e-01 | 1.0000e+00 |      425979 |     2048000 |         2000 |        2000 |         0.2 |reached target block errors\n",
      "   -0.091 | 1.6746e-01 | 1.0000e+00 |      342948 |     2048000 |         2000 |        2000 |         0.2 |reached target block errors\n",
      "    0.636 | 7.5977e-02 | 9.1400e-01 |      155601 |     2048000 |         1828 |        2000 |         0.2 |reached target block errors\n",
      "    1.364 | 1.6700e-03 | 7.1250e-02 |       13681 |     8192000 |          570 |        8000 |         0.8 |reached target block errors\n",
      "    2.091 | 6.9336e-07 | 4.0000e-05 |         142 |   204800000 |            8 |      200000 |        21.0 |reached max iterations\n",
      "    2.818 | 0.0000e+00 | 0.0000e+00 |           0 |   204800000 |            0 |      200000 |        21.0 |reached max iterations\n",
      "\n",
      "Simulation stopped as no error occurred @ EbNo = 2.8 dB.\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1600x1000 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "ber_plots.simulate(run_graph,\n",
    "                   ebno_dbs=np.linspace(EBN0_DB_MIN, EBN0_DB_MAX, 12),\n",
    "                   batch_size=BATCH_SIZE,\n",
    "                   num_target_block_errors=500,\n",
    "                   legend=\"Coded (Graph mode)\",\n",
    "                   soft_estimates=True,\n",
    "                   max_mc_iter=100,\n",
    "                   show_fig=True,\n",
    "                   forward_keyboard_interrupt=False);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "57cdb153",
   "metadata": {},
   "source": [
    "**Task:** TensorFlow allows to *compile* graphs with [XLA](https://www.tensorflow.org/xla). Try to further accelerate the code with XLA (`@tf.function(jit_compile=True)`).\n",
    "\n",
    "*Remark*: XLA is still an experimental feature and not all TensorFlow (and, thus, Sionna) functions support XLA.\n",
    "\n",
    "**Task 2:** Check the GPU load with `!nvidia-smi`. Find the best tradeoff between batch-size and throughput for your specific GPU architecture."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6d4765a0",
   "metadata": {},
   "source": [
    "## Exercise\n",
    "\n",
    "Simulate the coded bit error rate (BER) for a Polar coded and 64-QAM modulation.\n",
    "Assume a codeword length of n = 200 and coderate = 0.5.\n",
    "\n",
    "**Hint**: For Polar codes, successive cancellation list decoding (SCL) gives the best BER performance.\n",
    "However, successive cancellation (SC) decoding (without a list) is less complex.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "cf855e19",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-03-08T13:43:34.981858Z",
     "iopub.status.busy": "2025-03-08T13:43:34.981333Z",
     "iopub.status.idle": "2025-03-08T13:43:34.987471Z",
     "shell.execute_reply": "2025-03-08T13:43:34.986392Z"
    }
   },
   "outputs": [],
   "source": [
    "n = 200\n",
    "coderate = 0.5\n",
    "\n",
    "# *You can implement your code here*\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.16"
  },
  "widgets": {
   "application/vnd.jupyter.widget-state+json": {
    "state": {},
    "version_major": 2,
    "version_minor": 0
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
